package com.ruoyi.vqms.service.impl;

import com.ruoyi.common.constant.VQMSConstants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.vqms.domain.VQMSQueue;
import com.ruoyi.vqms.domain.VQMSQueueArea;
import com.ruoyi.vqms.domain.VQMSQueueReservation;
import com.ruoyi.vqms.domain.dto.*;
import com.ruoyi.vqms.mapper.VQMSQueueAreaMapper;
import com.ruoyi.vqms.mapper.VQMSQueueMapper;
import com.ruoyi.vqms.mapper.VQMSQueueReservationMapper;
import com.ruoyi.vqms.service.IVQMSQueueService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.*;

/**
 * 排队 服务层实现
 */
@Service
public class VQMSQueueServiceImpl implements IVQMSQueueService {
    @Autowired
    private VQMSQueueMapper vqmsQueueMapper;
    @Autowired
    private VQMSQueueReservationMapper vqmsQueueReservationMapper;
    @Autowired
    private VQMSQueueAreaMapper vqmsQueueAreaMapper;

    @Override
    public List<VQMSQueue> selectList(VQMSQueue vqmsQueue) {
        return vqmsQueueMapper.selectList(vqmsQueue);
    }

    @Override
    public int add(VQMSQueue vqmsQueue) {
        return vqmsQueueMapper.add(vqmsQueue);
    }

    @Override
    public int wxAdd(VQMSQueueReservation vqmsQueueReservation){

        //智能排队
        VQMSQueue queue=new VQMSQueue();
        queue.setFactoryId(vqmsQueueReservation.getFactoryId());
        queue.setReservationId(vqmsQueueReservation.getId());
        // 根据库位查找绑定的排队区域
        List<VQMSQueueArea> queueAreaList=vqmsQueueAreaMapper.getByLocationName(vqmsQueueReservation.getStorehouseLocationName());
        if(queueAreaList !=null && queueAreaList.size()>0){     //库位绑定有排队队列
            // 自动排队到最少的排队队列
            Long minAreaId=null;
            int minCount=Integer.MAX_VALUE;

            // 第一步：找到排队数量最少的队列
            for(VQMSQueueArea queueArea : queueAreaList){
                // 查询所在队列，正在排队/装卸货中的数量
                int countQueue=vqmsQueueMapper.countByAreaId(queueArea.getId());
                // 寻找排队数量最少的队列
                if(minAreaId == null || countQueue < minCount){
                    minAreaId=queueArea.getId();
                    minCount=countQueue;
                }
            }

            // 第二步：确定最终队列后，计算排队序号
            Integer maxQueueIndex=vqmsQueueMapper.getMaxQueueIndex(minAreaId);
            if(maxQueueIndex == null){
                maxQueueIndex=1;
            }else{
                maxQueueIndex = maxQueueIndex + 1;
            }

            queue.setAreaId(minAreaId);
            queue.setQueueIndex(maxQueueIndex);
            queue.setQueueTime(new Date());
            queue.setActualQueueTime(new Date());
            // 如果是当前队列没有车辆排队，则自动叫号，状态为：装卸货中
            if(minCount == 0){
                queue.setStatus(VQMSConstants.STATUS_QUEUE_LOADING);
                queue.setLoadingTime(new Date());
                // 否则状态为排队中
            }else{
                queue.setStatus(VQMSConstants.STATUS_QUEUE_WAIT);
            }
            queue.setCreateBy(vqmsQueueReservation.getDriverName());
            queue.setExpedited((long) 1);   //默认不加急
            vqmsQueueMapper.add(queue);
        } else {            //库位未绑定排队队列（只记录不排队）
            return  2;
        }
        return 1;


//        //智能排队
//        VQMSQueue queue=new VQMSQueue();
//        queue.setFactoryId(vqmsQueueReservation.getFactoryId());
//        queue.setReservationId(vqmsQueueReservation.getId());
//        // 根据库位查找绑定的排队区域
//        List<VQMSQueueArea> queueAreaList=vqmsQueueAreaMapper.getByLocationName(vqmsQueueReservation.getStorehouseLocationName());
//        if(queueAreaList !=null && queueAreaList.size()>0){     //库位绑定有排队队列
//            // 自动排队到最少的排队队列
//            Long minAreaId=0l;
//            int minCount=0;
//            Integer maxQueueIndex=null;
//            for(VQMSQueueArea queueArea : queueAreaList){
//                // 查询所在队列，正在排队/装卸货中的数量
//                int countQueue=vqmsQueueMapper.countByAreaId(queueArea.getId());
//                //先自动排队到第一个队列，再跟下一个队列的排队数量比较
//                if(minCount == 0 || minCount < countQueue){
//                    minAreaId=queueArea.getId();
//                    minCount=countQueue;
//                    // 查询所在队列，最大排队序号
//                    maxQueueIndex=vqmsQueueMapper.getMaxQueueIndex(queueArea.getId());
//                    if(maxQueueIndex == null){
//                        maxQueueIndex=1;
//                    }else{
//                        maxQueueIndex = maxQueueIndex + 1;
//                    }
//                }
//            }
//            queue.setAreaId(minAreaId);
//            queue.setQueueIndex(maxQueueIndex);
//            queue.setQueueTime(new Date());
//            queue.setActualQueueTime(new Date());
//            // 如果是当前队列没有车辆排队，则自动叫号，状态为：装卸货中
//            if(minCount == 0){
//                queue.setStatus(VQMSConstants.STATUS_QUEUE_LOADING);
//                queue.setLoadingTime(new Date());
//                // 否则状态为排队中
//            }else{
//                queue.setStatus(VQMSConstants.STATUS_QUEUE_WAIT);
//            }
//            queue.setCreateBy(vqmsQueueReservation.getDriverName());
//            queue.setExpedited((long) 1);   //默认不加急
//            vqmsQueueMapper.add(queue);
//        } else {            //库位未绑定排队队列（只记录不排队）
//            return  2;
//        }
//        return 1;
    }

    @Override
    public VQMSQueue getById(Long id) {
        return vqmsQueueMapper.getById(id);
    }

    @Override
    public VQMSQueue getByReservationId(Long reservationId) {
        return vqmsQueueMapper.getByReservationId(reservationId);
    }

    @Override
    public int update(VQMSQueue vqmsQueue) {
        return vqmsQueueMapper.update(vqmsQueue);
    }

    @Override
    public int delete(Long[] ids) {
        return vqmsQueueMapper.delete(ids);
    }

    @Override
    public int warehouseDelete(Long[] ids){
        return vqmsQueueMapper.delete(ids);
    }

    @Override
    public void topping(VQMSQueue vqmsQueue) {


        // 1. 使用现有方法获取未排序的排队列表
//        List<VQMSQueue> list = vqmsQueueMapper.getWaitingQueue(vqmsQueue.getAreaId());
//
//        if (list == null || list.isEmpty()) {
//            // 没有排队车辆，直接将自己设为1
//            vqmsQueue.setQueueIndex(1);
//            vqmsQueueMapper.update(vqmsQueue);
//            return;
//        }
//
//        // 2. 手动按queueIndex升序排序（关键改进点）
//        list.sort(Comparator.comparingInt(VQMSQueue::getQueueIndex));
//
//        // 3. 从列表中找到目标车辆并移除
//        VQMSQueue targetQueue = null;
//        Iterator<VQMSQueue> iterator = list.iterator();
//        while (iterator.hasNext()) {
//            VQMSQueue queue = iterator.next();
//            if (queue.getId().equals(vqmsQueue.getId())) {
//                targetQueue = queue;
//                iterator.remove();
//                break;
//            }
//        }
//
//        if (targetQueue == null) {
//            throw new IllegalArgumentException("未找到目标排队项");
//        }
//
//        // 4. 将目标车辆插入到列表头部
//        list.add(0, targetQueue);
//
//        // 5. 重新编号所有车辆（连续序号）
//        for (int i = 0; i < list.size(); i++) {
//            VQMSQueue queue = list.get(i);
//            queue.setQueueIndex(i + 1);
//            vqmsQueueMapper.update(queue);
//        }

//        //查询所在队列，装卸货中的序号
        VQMSQueue loadingQueue = vqmsQueueMapper.getLoadingQueue(vqmsQueue.getAreaId());
        int nowIndex = loadingQueue.getQueueIndex();
        //置顶自己
        vqmsQueue.setQueueIndex(nowIndex + 1);
        vqmsQueueMapper.update(vqmsQueue);
        //查询所在队列，所有排队中的集合
        List<VQMSQueue> list = vqmsQueueMapper.getWaitingQueue(vqmsQueue.getAreaId());
        if (list != null && list.size() > 0) {
            int index = 1;
            for (VQMSQueue queue : list) {
                //更新其余的排队序号
                if (queue.getId() != vqmsQueue.getId()) {
                    queue.setQueueIndex(vqmsQueue.getQueueIndex() + index);
                    vqmsQueueMapper.update(queue);
                    index++;
                }
            }
        }
    }

    @Override
    public void warehouseTopping(VQMSQueue vqmsQueue) {

        // 查询排队中的车辆（不含装卸货中的）
        List<VQMSQueue> waitingQueues = vqmsQueueMapper.getWaitingQueue(vqmsQueue.getAreaId());

        if (waitingQueues.isEmpty()) {
            throw new IllegalArgumentException("当天排队信息不存在");
        }

        // 查询装卸货中的车辆
        VQMSQueue loadingQueue = vqmsQueueMapper.getLoadingQueue(vqmsQueue.getAreaId());
        int loadingIndex = loadingQueue != null ? loadingQueue.getQueueIndex() : 0;

        // 找到要置顶的车辆并移除
        VQMSQueue targetQueue = waitingQueues.stream()
                .filter(q -> q.getId().equals(vqmsQueue.getId()))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("未找到指定排队项"));

        waitingQueues.remove(targetQueue);

        // 将目标车辆插入到头部
        waitingQueues.add(0, targetQueue);

        // 计算起始序号：如果有装卸货中的，从2开始；否则从1开始
        int startIndex = loadingIndex > 0 ? 2 : 1;

        // 重新编号排队中的车辆
        for (int i = 0; i < waitingQueues.size(); i++) {
            VQMSQueue queue = waitingQueues.get(i);
            queue.setQueueIndex(startIndex + i);
            vqmsQueueMapper.update(queue);
        }


//        //查询所在排队队列
//        List<VQMSQueue> list1 = vqmsQueueMapper.getWaitingQueue(vqmsQueue.getAreaId());
//        if (list1.isEmpty()){       //不存在当天排队的信息
//            try {
//                throw new Exception("当天排队信息不存在");
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//        }
//        VQMSQueue vqmsQueue2 = new VQMSQueue();
//        //查询所在队列，装卸货中的序号
//        VQMSQueue loadingQueue = vqmsQueueMapper.getLoadingQueue(vqmsQueue.getAreaId());    //查询当天
//        int nowIndex = 0;
//        if (loadingQueue != null){
//            nowIndex = loadingQueue.getQueueIndex();
//        }
//
//        int sun = 0;
//        //查询要置顶的对象
//        for (int i = 0; i < list1.size(); i++) {
//            if (Objects.equals(vqmsQueue.getId(), list1.get(i).getId())) {
//                vqmsQueue2 = list1.get(i);
//                sun = i;        //记住原来的下标
//            }
//        }
//
//        list1.remove(sun);
//        if (nowIndex == 0){     //没查出当天正在卸货的排队任务
//            list1.add(nowIndex, vqmsQueue2);
//        } else {
//            list1.add(nowIndex - 1, vqmsQueue2);    //排队序号-1=列表下标，列表是从第二条开始
//        }
//
//        for (VQMSQueue vqmsQueue1 : list1){     //重新赋值排队顺序
//            vqmsQueue1.setQueueIndex(nowIndex + 1);
//            vqmsQueueMapper.update(vqmsQueue1);
//            nowIndex += 1;      //如果当天没有正在排队的卸货任务，则排队顺序从1开始重新拍，有则从2开始
//        }
//        System.out.println("置顶列表--》" + list1);

    }

    //设置加急置顶(仓管)
    @Override
    public void expeditedTopping(VQMSQueue vqmsQueue){
        //查询所在排队队列
        List<VQMSQueue> list1 = vqmsQueueMapper.getWaitingQueue(vqmsQueue.getAreaId());
        if (list1.isEmpty()){       //不存在当天排队的信息
            try {
                throw new Exception("当天排队信息不存在");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        VQMSQueue vqmsQueue2 = new VQMSQueue();
        //查询所在队列，装卸货中的序号
        VQMSQueue loadingQueue = vqmsQueueMapper.getLoadingQueue(vqmsQueue.getAreaId());    //查询当天
        int nowIndex = 0;
        if (loadingQueue != null){
            nowIndex = loadingQueue.getQueueIndex();

            Long b = 2L;
            //查询装卸货后面有多少条加急排队
            for (VQMSQueue queue : list1) {
                if (Objects.equals(b, queue.getExpedited())) {      //加急排队
                    nowIndex = queue.getQueueIndex();
                }
            }
//            if(nowIndex == loadingQueue.getQueueIndex()){   //没有加急排队
//                nowIndex = 1;    //排队序号从2开始
//            }

        }

        int sun = 0;
        //查询要置顶的对象
        for (int i = 0; i < list1.size(); i++) {
            if (Objects.equals(vqmsQueue.getId(), list1.get(i).getId())) {
                vqmsQueue2 = list1.get(i);
                sun = i;        //记住原来的下标
            }
        }

        list1.remove(sun);
        if (nowIndex == 0){     //没查出当天正在卸货的排队任务
            list1.add(nowIndex, vqmsQueue2);
        } else {
            list1.add(nowIndex - 1, vqmsQueue2);    //排队序号-1=列表下标，列表是从第二条开始
        }

//        int newIndex = list1.get(0).getQueueIndex();
        int newIndex = 2;   //从2开始
        for (VQMSQueue vqmsQueue1 : list1){     //重新赋值排队顺序
            vqmsQueue1.setQueueIndex(newIndex);
            vqmsQueueMapper.update(vqmsQueue1);
            newIndex += 1;      //如果当天没有正在排队的卸货任务，则排队顺序从1开始重新拍，有则从2开始
        }
        System.out.println("置顶列表--》" + list1);
    }

    @Override
    public void next(VQMSQueue vqmsQueue) {
        // 状态设为已完成
        vqmsQueue.setStatus(VQMSConstants.STATUS_QUEUE_END);        //STATUS_QUEUE_END=3
        vqmsQueue.setEndTime(new Date());

        vqmsQueueMapper.update(vqmsQueue);
        // 预约记录状态设为已完成
        VQMSQueueReservation vqmsQueueReservation = vqmsQueueReservationMapper.getById(vqmsQueue.getReservationId());
        if (vqmsQueueReservation != null) {
            vqmsQueueReservation.setStatus(VQMSConstants.STATUS_RESERVATION_END);       //STATUS_RESERVATION_END=3
            vqmsQueueReservation.setCompleteTime(new Date());
            vqmsQueueReservation.setUpdateBy(vqmsQueue.getCreateBy());
            vqmsQueueReservationMapper.update(vqmsQueueReservation);
        }
        //查询所在队列，所有排队中的集合
        List<VQMSQueue> list = vqmsQueueMapper.getWaitingQueue(vqmsQueue.getAreaId());
        if (list != null && list.size() > 0) {
            for (VQMSQueue queue : list){
                //将排队顺序往前移一位，排第二的状态改为装卸货
                if (queue.getQueueIndex() == 2){
                    queue.setStatus(VQMSConstants.STATUS_QUEUE_LOADING);//2
                    queue.setLoadingTime(new Date());
                }
                queue.setQueueIndex(queue.getQueueIndex() - 1);
                vqmsQueueMapper.update(queue);

//                VQMSQueue vqmsQueue1 = list.get(0);
//                // 下一个状态设为装卸货中
//                vqmsQueue1.setStatus(VQMSConstants.STATUS_QUEUE_LOADING);
//                vqmsQueue1.setLoadingTime(new Date());
//                vqmsQueueMapper.update(vqmsQueue1);

            }
        }
    }

    /**
     * 排队中的完成装卸货
     */
    @Override
    public void queueNext(VQMSQueue vqmsQueue){
        // 状态设为已完成
        vqmsQueue.setStatus(VQMSConstants.STATUS_QUEUE_END);        //STATUS_QUEUE_END = 3
        vqmsQueue.setEndTime(new Date());

        vqmsQueueMapper.update(vqmsQueue);
        // 预约记录状态设为已完成
        VQMSQueueReservation vqmsQueueReservation = vqmsQueueReservationMapper.getById(vqmsQueue.getReservationId());
        if (vqmsQueueReservation != null) {
            vqmsQueueReservation.setStatus(VQMSConstants.STATUS_RESERVATION_END);   //STATUS_RESERVATION_END = 3
            vqmsQueueReservation.setCompleteTime(new Date());
            vqmsQueueReservation.setUpdateBy(vqmsQueue.getCreateBy());
            vqmsQueueReservationMapper.update(vqmsQueueReservation);
        }
        //查询所在队列，所有排队中的集合
        List<VQMSQueue> list = vqmsQueueMapper.getMoreThanWaitingQueue(vqmsQueue.getAreaId(), vqmsQueue.getQueueIndex());
        if (list != null && list.size() > 0) {
            for (VQMSQueue queue : list){
                //将排队顺序往前移一位，排第二的状态改为装卸货
//                if (queue.getQueueIndex() == 2){
//                    queue.setStatus(VQMSConstants.STATUS_QUEUE_LOADING);
//                    queue.setLoadingTime(new Date());
//                }
                queue.setQueueIndex(queue.getQueueIndex() - 1);
                vqmsQueueMapper.update(queue);

            }
        }
    }

    @Override
    public void change(VQMSQueue vqmsQueue) {
        //更新原队列中所有的排队序号大于自己排队序号的记录，全部前进一位
        List<VQMSQueue> list = vqmsQueueMapper.getMoreThanWaitingQueue(vqmsQueue.getAreaId(), vqmsQueue.getQueueIndex());
        if (list != null && list.size() > 0) {
            for (VQMSQueue queue : list) {
                //前进一位
                queue.setQueueIndex(queue.getQueueIndex() - 1);
                vqmsQueueMapper.update(queue);
            }
        }
        //默认排到更换队列的最后一位
        Integer maxQueueIndex = vqmsQueueMapper.getMaxQueueIndex(vqmsQueue.getNewAreaId());
        vqmsQueue.setAreaId(vqmsQueue.getNewAreaId());
        vqmsQueue.setQueueIndex(maxQueueIndex == null ? 1 : maxQueueIndex + 1);
        //如果排第一位则状态改为装卸货中
        if(vqmsQueue.getQueueIndex() == 1){
            vqmsQueue.setStatus(2);
        }

        vqmsQueueMapper.update(vqmsQueue);
    }

    /**
     * 排队跳过
     * @param vqmsQueue
     */
    @Override
    public void skip(VQMSQueue vqmsQueue) {
//        return ;
        //查询当日排队中列表
        List<VQMSQueue> list = vqmsQueueMapper.getMoreThanWaitingQueue(vqmsQueue.getAreaId(), vqmsQueue.getQueueIndex());
        VQMSQueue vqmsQueue1 = null;
        if (list != null && list.size() > 0){
            for (VQMSQueue queue : list) {
                if (queue.getQueueIndex() == (vqmsQueue.getQueueIndex() + 1)) {    //排队序号等于下一条
                    vqmsQueue1 = queue;
                    break;
                }
            }
        }
        if (vqmsQueue1 != null){    //有下一条排队,交换排队序号和状态
            Integer n = vqmsQueue1.getQueueIndex();
            vqmsQueue1.setQueueIndex(vqmsQueue.getQueueIndex());
            vqmsQueue1.setStatus(VQMSConstants.STATUS_QUEUE_LOADING);       //装卸货中
            vqmsQueueMapper.update(vqmsQueue1);

            vqmsQueue.setQueueIndex(n);
            vqmsQueue.setStatus(VQMSConstants.STATUS_QUEUE_WAIT);   //排队中
            vqmsQueueMapper.update(vqmsQueue);
        } else {
            throw new IllegalStateException("无下一条排队");
        }
    }

    /**
     * 按排队顺序查询排队车辆
     *
     * @return
     */
    @Override
    public List<VQMSQueue> getQueueList(Long areaId) {
        return vqmsQueueMapper.getQueueList(areaId);
    }

    @Override
    public List<VQMSQueue> selectYesterdayWaitingQueue() {
        return vqmsQueueMapper.selectYesterdayWaitingQueue();
    }

    /**
     * 仓管员查询当日排队信息
     * @param vqmsQueue
     * @return
     */
    @Override
    public List<VQMSQueue> warehouseSelectList(VQMSQueue vqmsQueue,List<String> locationList){
        return vqmsQueueMapper.warehouseSelectList(vqmsQueue,locationList);
    }

    /**
     * 查询司机是否有未完成排队
     * @param driverPhone
     * @return
     */
    @Override
    public List<VQMSQueue> selectQueue(String driverPhone){
        return vqmsQueueMapper.selectQueue(driverPhone);
    }

    /**
     * 查询当日排队信息（状态为装卸货中或者排队中）
     * @param vqmsQueue
     * @return
     */
    @Override
    public List<VQMSQueue> selectQueueList(VQMSQueue vqmsQueue){
        return vqmsQueueMapper.selectQueueList(vqmsQueue);
    }

    /**
     * 查询所有未完成的排队
     * @return
     */
    @Override
    public List<VQMSQueue> selectTimeoutList(){
        return vqmsQueueMapper.selectTimeoutList();
    }

    /**
     * 根据队列ID查询所有未完成的排队
     * @return
     */
    @Override
    public List<VQMSQueue> selectAreaTimeoutList(Long areaId){
        return vqmsQueueMapper.selectAreaTimeoutList(areaId);
    }

    /**
     * 查询当日未完成的排队(数据大屏)
     * @return
     */
    @Override
    public List<ToDayQueueVO> selectToDayList(){
        return vqmsQueueMapper.selectToDayList();
    }

    /**
     * 统计今日排队信息
     * @return
     */
    @Override
    public ToDayQueueSummaryVO statisticsToDayQueue(){
        return vqmsQueueMapper.statisticsToDayQueue();
    }

    /**
     * 统计排队车牌省市比例
     * @return
     */
    @Override
    public List<CityProportionVO> selectCity(){
        return vqmsQueueMapper.selectCity();
    }

    /**
     * 统计近7日仓库排队时间段峰值
     * @return
     */
    @Override
    public List<QueueTimePeakValueVO> selectQueuePeak(){
        return vqmsQueueMapper.selectQueuePeak();
    }

    /**
     * 统计近7日排队队列总数
     * @return
     */
    @Override
    public List<AreaQueueVO> selectAreaCount(){
        return vqmsQueueMapper.selectAreaCount();
    }
}
